package com.steve.combat.thread.同步器;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author: STEVE
 * @Description: 使用CountDownLatch循环处理数据
 * @since: 2025-05-21
 */
public class SimpleDataProcessor {

    public static void main(String[] args) {
        // 1. 准备测试数据
        List<String> data = Arrays.asList("数据1", "数据2", "数据3", "数据4", "数据5",
                "数据6", "数据7", "数据8", "数据9", "数据10");

        // 2. 使用普通循环处理
        processData(data);

        // 3. 使用CountDownLatch多线程处理
        processData2(data);

        // 4. 使用线程池配合CountDownLatch处理
        processData3(data);
    }

    private static void processData(List<String> data) {
        long startTime = System.currentTimeMillis();

        // 遍历数据集合
        for (String item : data) {
            String result = processItem(item);
            System.out.println(Thread.currentThread().getName() + " 处理结果：" + result);

        }

        System.out.println("使用普通循环处理所有数据完成, 耗时：" + (System.currentTimeMillis() - startTime));
    }

    private static void processData2(List<String> data) {
        // 创建CountDownLatch，计数器初始化为数据条数
        CountDownLatch latch = new CountDownLatch(data.size());
        long startTime = System.currentTimeMillis();

        // 遍历数据集合
        for (String item : data) {
            // 为每条数据创建一个线程处理
            new Thread(() -> {
                try {
                    // 处理单条数据（实际业务逻辑）
                    String result = processItem(item);
                    System.out.println(Thread.currentThread().getName() + " 处理结果：" + result);
                } finally {
                    // 无论处理成功与否，都减少计数器
                    latch.countDown();
                }
            }).start();

        }

        try {
            // 主线程等待所有数据处理完成
            latch.await();
            System.out.println("使用CountDownLatch多线程处理所有数据完成, 耗时：" + (System.currentTimeMillis() - startTime));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("处理被中断");
        }
    }

    private static void processData3(List<String> data) {
        // 创建线程池（固定四个线程）
        ExecutorService pool = Executors.newFixedThreadPool(4);
        // 创建CountDownLatch，计数器初始化为数据条数
        CountDownLatch latch = new CountDownLatch(data.size());
        long startTime = System.currentTimeMillis();

        // 遍历数据集合
        for (String item : data) {
            pool.execute(() -> {
                try {
                    // 处理单条数据（实际业务逻辑）
                    String result = processItem(item);
                    System.out.println(Thread.currentThread().getName() + " 处理结果：" + result);
                } finally {
                    // 无论处理成功与否，都减少计数器
                    latch.countDown();
                }
            });
        }

        try {
            // 主线程等待所有数据处理完成
            latch.await();
            System.out.println("使用CountDownLatch配合线程池处理所有数据完成, 耗时：" + (System.currentTimeMillis() - startTime));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("处理被中断");
        }
    }

    // 模拟单条数据处理（实际业务逻辑）
    private static String processItem(String item) {
        try {
            // 模拟处理耗时
            Thread.sleep(100);
            return item.toUpperCase();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return "处理中断";
        }
    }

}
